// CodeMirror, copyright (c) by Marijn Haverbeke and others
// Distributed under an MIT license: https://codemirror.net/LICENSE

(function (mod) {
    if (typeof exports == "object" && typeof module == "object") // CommonJS
        mod(require("../../lib/codemirror"));
    else if (typeof define == "function" && define.amd) // AMD
        define(["../../lib/codemirror"], mod);
    else // Plain browser env
        mod(CodeMirror);
})(function (CodeMirror) {
    "use strict";
    var GUTTER_ID = "CodeMirror-lint-markers";

    function showTooltip(cm, e, content) {
        var tt = document.createElement("div");
        tt.className = "CodeMirror-lint-tooltip cm-s-" + cm.options.theme;
        tt.appendChild(content.cloneNode(true));
        if (cm.state.lint.options.selfContain)
            cm.getWrapperElement().appendChild(tt);
        else
            document.body.appendChild(tt);

        function position(e) {
            if (!tt.parentNode) return CodeMirror.off(document, "mousemove", position);
            tt.style.top = Math.max(0, e.clientY - tt.offsetHeight - 5) + "px";
            tt.style.left = (e.clientX + 5) + "px";
        }

        CodeMirror.on(document, "mousemove", position);
        position(e);
        if (tt.style.opacity != null) tt.style.opacity = 1;
        return tt;
    }

    function rm(elt) {
        if (elt.parentNode) elt.parentNode.removeChild(elt);
    }

    function hideTooltip(tt) {
        if (!tt.parentNode) return;
        if (tt.style.opacity == null) rm(tt);
        tt.style.opacity = 0;
        setTimeout(function () {
            rm(tt);
        }, 600);
    }

    function showTooltipFor(cm, e, content, node) {
        var tooltip = showTooltip(cm, e, content);

        function hide() {
            CodeMirror.off(node, "mouseout", hide);
            if (tooltip) {
                hideTooltip(tooltip);
                tooltip = null;
            }
        }

        var poll = setInterval(function () {
            if (tooltip) for (var n = node; ; n = n.parentNode) {
                if (n && n.nodeType == 11) n = n.host;
                if (n == document.body) return;
                if (!n) {
                    hide();
                    break;
                }
            }
            if (!tooltip) return clearInterval(poll);
        }, 400);
        CodeMirror.on(node, "mouseout", hide);
    }

    function LintState(cm, options, hasGutter) {
        this.marked = [];
        this.options = options;
        this.timeout = null;
        this.hasGutter = hasGutter;
        this.onMouseOver = function (e) {
            onMouseOver(cm, e);
        };
        this.waitingFor = 0
    }

    function parseOptions(_cm, options) {
        if (options instanceof Function) return {getAnnotations: options};
        if (!options || options === true) options = {};
        return options;
    }

    function clearMarks(cm) {
        var state = cm.state.lint;
        if (state.hasGutter) cm.clearGutter(GUTTER_ID);
        for (var i = 0; i < state.marked.length; ++i)
            state.marked[i].clear();
        state.marked.length = 0;
    }

    function makeMarker(cm, labels, severity, multiple, tooltips) {
        var marker = document.createElement("div"), inner = marker;
        marker.className = "CodeMirror-lint-marker CodeMirror-lint-marker-" + severity;
        if (multiple) {
            inner = marker.appendChild(document.createElement("div"));
            inner.className = "CodeMirror-lint-marker CodeMirror-lint-marker-multiple";
        }

        if (tooltips != false) CodeMirror.on(inner, "mouseover", function (e) {
            showTooltipFor(cm, e, labels, inner);
        });

        return marker;
    }

    function getMaxSeverity(a, b) {
        if (a == "error") return a;
        else return b;
    }

    function groupByLine(annotations) {
        var lines = [];
        for (var i = 0; i < annotations.length; ++i) {
            var ann = annotations[i], line = ann.from.line;
            (lines[line] || (lines[line] = [])).push(ann);
        }
        return lines;
    }

    function annotationTooltip(ann) {
        var severity = ann.severity;
        if (!severity) severity = "error";
        var tip = document.createElement("div");
        tip.className = "CodeMirror-lint-message CodeMirror-lint-message-" + severity;
        if (typeof ann.messageHTML != 'undefined') {
            tip.innerHTML = ann.messageHTML;
        } else {
            tip.appendChild(document.createTextNode(ann.message));
        }
        return tip;
    }

    function lintAsync(cm, getAnnotations, passOptions) {
        var state = cm.state.lint
        var id = ++state.waitingFor

        function abort() {
            id = -1
            cm.off("change", abort)
        }

        cm.on("change", abort)
        getAnnotations(cm.getValue(), function (annotations, arg2) {
            cm.off("change", abort)
            if (state.waitingFor != id) return
            if (arg2 && annotations instanceof CodeMirror) annotations = arg2
            cm.operation(function () {
                updateLinting(cm, annotations)
            })
        }, passOptions, cm);
    }

    function startLinting(cm) {
        var state = cm.state.lint, options = state.options;
        /*
         * Passing rules in `options` property prevents JSHint (and other linters) from complaining
         * about unrecognized rules like `onUpdateLinting`, `delay`, `lintOnChange`, etc.
         */
        var passOptions = options.options || options;
        var getAnnotations = options.getAnnotations || cm.getHelper(CodeMirror.Pos(0, 0), "lint");
        if (!getAnnotations) return;
        if (options.async || getAnnotations.async) {
            lintAsync(cm, getAnnotations, passOptions)
        } else {
            var annotations = getAnnotations(cm.getValue(), passOptions, cm);
            if (!annotations) return;
            if (annotations.then) annotations.then(function (issues) {
                cm.operation(function () {
                    updateLinting(cm, issues)
                })
            });
            else cm.operation(function () {
                updateLinting(cm, annotations)
            })
        }
    }

    function updateLinting(cm, annotationsNotSorted) {
        clearMarks(cm);
        var state = cm.state.lint, options = state.options;

        var annotations = groupByLine(annotationsNotSorted);

        for (var line = 0; line < annotations.length; ++line) {
            var anns = annotations[line];
            if (!anns) continue;

            // filter out duplicate messages
            var message = [];
            anns = anns.filter(function (item) {
                return message.indexOf(item.message) > -1 ? false : message.push(item.message)
            });

            var maxSeverity = null;
            var tipLabel = state.hasGutter && document.createDocumentFragment();

            for (var i = 0; i < anns.length; ++i) {
                var ann = anns[i];
                var severity = ann.severity;
                if (!severity) severity = "error";
                maxSeverity = getMaxSeverity(maxSeverity, severity);

                if (options.formatAnnotation) ann = options.formatAnnotation(ann);
                if (state.hasGutter) tipLabel.appendChild(annotationTooltip(ann));

                if (ann.to) state.marked.push(cm.markText(ann.from, ann.to, {
                    className: "CodeMirror-lint-mark CodeMirror-lint-mark-" + severity,
                    __annotation: ann
                }));
            }
            // use original annotations[line] to show multiple messages
            if (state.hasGutter)
                cm.setGutterMarker(line, GUTTER_ID, makeMarker(cm, tipLabel, maxSeverity, annotations[line].length > 1,
                    state.options.tooltips));
        }
        if (options.onUpdateLinting) options.onUpdateLinting(annotationsNotSorted, annotations, cm);
    }

    function onChange(cm) {
        var state = cm.state.lint;
        if (!state) return;
        clearTimeout(state.timeout);
        state.timeout = setTimeout(function () {
            startLinting(cm);
        }, state.options.delay || 500);
    }

    function popupTooltips(cm, annotations, e) {
        var target = e.target || e.srcElement;
        var tooltip = document.createDocumentFragment();
        for (var i = 0; i < annotations.length; i++) {
            var ann = annotations[i];
            tooltip.appendChild(annotationTooltip(ann));
        }
        showTooltipFor(cm, e, tooltip, target);
    }

    function onMouseOver(cm, e) {
        var target = e.target || e.srcElement;
        if (!/\bCodeMirror-lint-mark-/.test(target.className)) return;
        var box = target.getBoundingClientRect(), x = (box.left + box.right) / 2, y = (box.top + box.bottom) / 2;
        var spans = cm.findMarksAt(cm.coordsChar({left: x, top: y}, "client"));

        var annotations = [];
        for (var i = 0; i < spans.length; ++i) {
            var ann = spans[i].__annotation;
            if (ann) annotations.push(ann);
        }
        if (annotations.length) popupTooltips(cm, annotations, e);
    }

    CodeMirror.defineOption("lint", false, function (cm, val, old) {
        if (old && old != CodeMirror.Init) {
            clearMarks(cm);
            if (cm.state.lint.options.lintOnChange !== false)
                cm.off("change", onChange);
            CodeMirror.off(cm.getWrapperElement(), "mouseover", cm.state.lint.onMouseOver);
            clearTimeout(cm.state.lint.timeout);
            delete cm.state.lint;
        }

        if (val) {
            var gutters = cm.getOption("gutters"), hasLintGutter = false;
            for (var i = 0; i < gutters.length; ++i) if (gutters[i] == GUTTER_ID) hasLintGutter = true;
            var state = cm.state.lint = new LintState(cm, parseOptions(cm, val), hasLintGutter);
            if (state.options.lintOnChange !== false)
                cm.on("change", onChange);
            if (state.options.tooltips != false && state.options.tooltips != "gutter")
                CodeMirror.on(cm.getWrapperElement(), "mouseover", state.onMouseOver);

            startLinting(cm);
        }
    });

    CodeMirror.defineExtension("performLint", function () {
        if (this.state.lint) startLinting(this);
    });
});